home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / compiler / symbols.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-11-11  |  18KB  |  488 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''Module symbol-table generator'''
  5. from compiler import ast
  6. from compiler.consts import SC_LOCAL, SC_GLOBAL, SC_FREE, SC_CELL, SC_UNKNOWN
  7. from compiler.misc import mangle
  8. import types
  9. import sys
  10. MANGLE_LEN = 256
  11.  
  12. class Scope:
  13.     
  14.     def __init__(self, name, module, klass = None):
  15.         self.name = name
  16.         self.module = module
  17.         self.defs = { }
  18.         self.uses = { }
  19.         self.globals = { }
  20.         self.params = { }
  21.         self.frees = { }
  22.         self.cells = { }
  23.         self.children = []
  24.         self.nested = None
  25.         self.generator = None
  26.         self.klass = None
  27.         if klass is not None:
  28.             for i in range(len(klass)):
  29.                 if klass[i] != '_':
  30.                     self.klass = klass[i:]
  31.                     break
  32.                     continue
  33.             
  34.         
  35.  
  36.     
  37.     def __repr__(self):
  38.         return '<%s: %s>' % (self.__class__.__name__, self.name)
  39.  
  40.     
  41.     def mangle(self, name):
  42.         if self.klass is None:
  43.             return name
  44.         return mangle(name, self.klass)
  45.  
  46.     
  47.     def add_def(self, name):
  48.         self.defs[self.mangle(name)] = 1
  49.  
  50.     
  51.     def add_use(self, name):
  52.         self.uses[self.mangle(name)] = 1
  53.  
  54.     
  55.     def add_global(self, name):
  56.         name = self.mangle(name)
  57.         if name in self.uses or name in self.defs:
  58.             pass
  59.         
  60.         if name in self.params:
  61.             raise SyntaxError, '%s in %s is global and parameter' % (name, self.name)
  62.         name in self.params
  63.         self.globals[name] = 1
  64.         self.module.add_def(name)
  65.  
  66.     
  67.     def add_param(self, name):
  68.         name = self.mangle(name)
  69.         self.defs[name] = 1
  70.         self.params[name] = 1
  71.  
  72.     
  73.     def get_names(self):
  74.         d = { }
  75.         d.update(self.defs)
  76.         d.update(self.uses)
  77.         d.update(self.globals)
  78.         return d.keys()
  79.  
  80.     
  81.     def add_child(self, child):
  82.         self.children.append(child)
  83.  
  84.     
  85.     def get_children(self):
  86.         return self.children
  87.  
  88.     
  89.     def DEBUG(self):
  90.         print >>sys.stderr, self.name,
  91.         if not self.nested or 'nested':
  92.             pass
  93.         print >>sys.stderr, ''
  94.         print >>sys.stderr, '\tglobals: ', self.globals
  95.         print >>sys.stderr, '\tcells: ', self.cells
  96.         print >>sys.stderr, '\tdefs: ', self.defs
  97.         print >>sys.stderr, '\tuses: ', self.uses
  98.         print >>sys.stderr, '\tfrees:', self.frees
  99.  
  100.     
  101.     def check_name(self, name):
  102.         '''Return scope of name.
  103.  
  104.         The scope of a name could be LOCAL, GLOBAL, FREE, or CELL.
  105.         '''
  106.         if name in self.globals:
  107.             return SC_GLOBAL
  108.         if name in self.cells:
  109.             return SC_CELL
  110.         if name in self.defs:
  111.             return SC_LOCAL
  112.         if self.nested:
  113.             if name in self.frees or name in self.uses:
  114.                 return SC_FREE
  115.             if self.nested:
  116.                 return SC_UNKNOWN
  117.             return SC_GLOBAL
  118.         return self.nested
  119.  
  120.     
  121.     def get_free_vars(self):
  122.         if not self.nested:
  123.             return ()
  124.         free = { }
  125.         free.update(self.frees)
  126.         for name in self.uses.keys():
  127.             if name not in self.defs and name not in self.globals:
  128.                 free[name] = 1
  129.                 continue
  130.             self.nested
  131.         
  132.         return free.keys()
  133.  
  134.     
  135.     def handle_children(self):
  136.         for child in self.children:
  137.             frees = child.get_free_vars()
  138.             globals = self.add_frees(frees)
  139.             for name in globals:
  140.                 child.force_global(name)
  141.             
  142.         
  143.  
  144.     
  145.     def force_global(self, name):
  146.         '''Force name to be global in scope.
  147.  
  148.         Some child of the current node had a free reference to name.
  149.         When the child was processed, it was labelled a free
  150.         variable.  Now that all its enclosing scope have been
  151.         processed, the name is known to be a global or builtin.  So
  152.         walk back down the child chain and set the name to be global
  153.         rather than free.
  154.  
  155.         Be careful to stop if a child does not think the name is
  156.         free.
  157.         '''
  158.         self.globals[name] = 1
  159.         if name in self.frees:
  160.             del self.frees[name]
  161.         
  162.         for child in self.children:
  163.             if child.check_name(name) == SC_FREE:
  164.                 child.force_global(name)
  165.                 continue
  166.         
  167.  
  168.     
  169.     def add_frees(self, names):
  170.         '''Process list of free vars from nested scope.
  171.  
  172.         Returns a list of names that are either 1) declared global in the
  173.         parent or 2) undefined in a top-level parent.  In either case,
  174.         the nested scope should treat them as globals.
  175.         '''
  176.         child_globals = []
  177.         for name in names:
  178.             sc = self.check_name(name)
  179.             if self.nested:
  180.                 if sc == SC_UNKNOWN and sc == SC_FREE or isinstance(self, ClassScope):
  181.                     self.frees[name] = 1
  182.                 elif sc == SC_GLOBAL:
  183.                     child_globals.append(name)
  184.                 elif isinstance(self, FunctionScope) and sc == SC_LOCAL:
  185.                     self.cells[name] = 1
  186.                 elif sc != SC_CELL:
  187.                     child_globals.append(name)
  188.                 
  189.             sc == SC_LOCAL
  190.             if sc == SC_LOCAL:
  191.                 self.cells[name] = 1
  192.                 continue
  193.             if sc != SC_CELL:
  194.                 child_globals.append(name)
  195.                 continue
  196.         
  197.         return child_globals
  198.  
  199.     
  200.     def get_cell_vars(self):
  201.         return self.cells.keys()
  202.  
  203.  
  204.  
  205. class ModuleScope(Scope):
  206.     __super_init = Scope.__init__
  207.     
  208.     def __init__(self):
  209.         self._ModuleScope__super_init('global', self)
  210.  
  211.  
  212.  
  213. class FunctionScope(Scope):
  214.     pass
  215.  
  216.  
  217. class GenExprScope(Scope):
  218.     __super_init = Scope.__init__
  219.     __counter = 1
  220.     
  221.     def __init__(self, module, klass = None):
  222.         i = self._GenExprScope__counter
  223.         self._GenExprScope__counter += 1
  224.         self._GenExprScope__super_init('generator expression<%d>' % i, module, klass)
  225.         self.add_param('.0')
  226.  
  227.     
  228.     def get_names(self):
  229.         keys = Scope.get_names(self)
  230.         return keys
  231.  
  232.  
  233.  
  234. class LambdaScope(FunctionScope):
  235.     __super_init = Scope.__init__
  236.     __counter = 1
  237.     
  238.     def __init__(self, module, klass = None):
  239.         i = self._LambdaScope__counter
  240.         self._LambdaScope__counter += 1
  241.         self._LambdaScope__super_init('lambda.%d' % i, module, klass)
  242.  
  243.  
  244.  
  245. class ClassScope(Scope):
  246.     __super_init = Scope.__init__
  247.     
  248.     def __init__(self, name, module):
  249.         self._ClassScope__super_init(name, module, name)
  250.  
  251.  
  252.  
  253. class SymbolVisitor:
  254.     
  255.     def __init__(self):
  256.         self.scopes = { }
  257.         self.klass = None
  258.  
  259.     
  260.     def visitModule(self, node):
  261.         scope = self.module = self.scopes[node] = ModuleScope()
  262.         self.visit(node.node, scope)
  263.  
  264.     visitExpression = visitModule
  265.     
  266.     def visitFunction(self, node, parent):
  267.         if node.decorators:
  268.             self.visit(node.decorators, parent)
  269.         
  270.         parent.add_def(node.name)
  271.         for n in node.defaults:
  272.             self.visit(n, parent)
  273.         
  274.         scope = FunctionScope(node.name, self.module, self.klass)
  275.         if parent.nested or isinstance(parent, FunctionScope):
  276.             scope.nested = 1
  277.         
  278.         self.scopes[node] = scope
  279.         self._do_args(scope, node.argnames)
  280.         self.visit(node.code, scope)
  281.         self.handle_free_vars(scope, parent)
  282.  
  283.     
  284.     def visitGenExpr(self, node, parent):
  285.         scope = GenExprScope(self.module, self.klass)
  286.         if parent.nested and isinstance(parent, FunctionScope) or isinstance(parent, GenExprScope):
  287.             scope.nested = 1
  288.         
  289.         self.scopes[node] = scope
  290.         self.visit(node.code, scope)
  291.         self.handle_free_vars(scope, parent)
  292.  
  293.     
  294.     def visitGenExprInner(self, node, scope):
  295.         for genfor in node.quals:
  296.             self.visit(genfor, scope)
  297.         
  298.         self.visit(node.expr, scope)
  299.  
  300.     
  301.     def visitGenExprFor(self, node, scope):
  302.         self.visit(node.assign, scope, 1)
  303.         self.visit(node.iter, scope)
  304.         for if_ in node.ifs:
  305.             self.visit(if_, scope)
  306.         
  307.  
  308.     
  309.     def visitGenExprIf(self, node, scope):
  310.         self.visit(node.test, scope)
  311.  
  312.     
  313.     def visitLambda(self, node, parent, assign = 0):
  314.         if not not assign:
  315.             raise AssertionError
  316.         for n in node.defaults:
  317.             self.visit(n, parent)
  318.         
  319.         scope = LambdaScope(self.module, self.klass)
  320.         if parent.nested or isinstance(parent, FunctionScope):
  321.             scope.nested = 1
  322.         
  323.         self.scopes[node] = scope
  324.         self._do_args(scope, node.argnames)
  325.         self.visit(node.code, scope)
  326.         self.handle_free_vars(scope, parent)
  327.  
  328.     
  329.     def _do_args(self, scope, args):
  330.         for name in args:
  331.             if type(name) == types.TupleType:
  332.                 self._do_args(scope, name)
  333.                 continue
  334.             scope.add_param(name)
  335.         
  336.  
  337.     
  338.     def handle_free_vars(self, scope, parent):
  339.         parent.add_child(scope)
  340.         scope.handle_children()
  341.  
  342.     
  343.     def visitClass(self, node, parent):
  344.         parent.add_def(node.name)
  345.         for n in node.bases:
  346.             self.visit(n, parent)
  347.         
  348.         scope = ClassScope(node.name, self.module)
  349.         if parent.nested or isinstance(parent, FunctionScope):
  350.             scope.nested = 1
  351.         
  352.         if node.doc is not None:
  353.             scope.add_def('__doc__')
  354.         
  355.         scope.add_def('__module__')
  356.         self.scopes[node] = scope
  357.         prev = self.klass
  358.         self.klass = node.name
  359.         self.visit(node.code, scope)
  360.         self.klass = prev
  361.         self.handle_free_vars(scope, parent)
  362.  
  363.     
  364.     def visitName(self, node, scope, assign = 0):
  365.         if assign:
  366.             scope.add_def(node.name)
  367.         else:
  368.             scope.add_use(node.name)
  369.  
  370.     
  371.     def visitFor(self, node, scope):
  372.         self.visit(node.assign, scope, 1)
  373.         self.visit(node.list, scope)
  374.         self.visit(node.body, scope)
  375.         if node.else_:
  376.             self.visit(node.else_, scope)
  377.         
  378.  
  379.     
  380.     def visitFrom(self, node, scope):
  381.         for name, asname in node.names:
  382.             if name == '*':
  383.                 continue
  384.             
  385.             if not asname:
  386.                 pass
  387.             scope.add_def(name)
  388.         
  389.  
  390.     
  391.     def visitImport(self, node, scope):
  392.         for name, asname in node.names:
  393.             i = name.find('.')
  394.             if i > -1:
  395.                 name = name[:i]
  396.             
  397.             if not asname:
  398.                 pass
  399.             scope.add_def(name)
  400.         
  401.  
  402.     
  403.     def visitGlobal(self, node, scope):
  404.         for name in node.names:
  405.             scope.add_global(name)
  406.         
  407.  
  408.     
  409.     def visitAssign(self, node, scope):
  410.         """Propagate assignment flag down to child nodes.
  411.  
  412.         The Assign node doesn't itself contains the variables being
  413.         assigned to.  Instead, the children in node.nodes are visited
  414.         with the assign flag set to true.  When the names occur in
  415.         those nodes, they are marked as defs.
  416.  
  417.         Some names that occur in an assignment target are not bound by
  418.         the assignment, e.g. a name occurring inside a slice.  The
  419.         visitor handles these nodes specially; they do not propagate
  420.         the assign flag to their children.
  421.         """
  422.         for n in node.nodes:
  423.             self.visit(n, scope, 1)
  424.         
  425.         self.visit(node.expr, scope)
  426.  
  427.     
  428.     def visitAssName(self, node, scope, assign = 1):
  429.         scope.add_def(node.name)
  430.  
  431.     
  432.     def visitAssAttr(self, node, scope, assign = 0):
  433.         self.visit(node.expr, scope, 0)
  434.  
  435.     
  436.     def visitSubscript(self, node, scope, assign = 0):
  437.         self.visit(node.expr, scope, 0)
  438.         for n in node.subs:
  439.             self.visit(n, scope, 0)
  440.         
  441.  
  442.     
  443.     def visitSlice(self, node, scope, assign = 0):
  444.         self.visit(node.expr, scope, 0)
  445.         if node.lower:
  446.             self.visit(node.lower, scope, 0)
  447.         
  448.         if node.upper:
  449.             self.visit(node.upper, scope, 0)
  450.         
  451.  
  452.     
  453.     def visitAugAssign(self, node, scope):
  454.         self.visit(node.node, scope)
  455.         if isinstance(node.node, ast.Name):
  456.             self.visit(node.node, scope, 1)
  457.         
  458.         self.visit(node.expr, scope)
  459.  
  460.     _const_types = (types.StringType, types.IntType, types.FloatType)
  461.     
  462.     def visitIf(self, node, scope):
  463.         for test, body in node.tests:
  464.             if isinstance(test, ast.Const):
  465.                 if type(test.value) in self._const_types:
  466.                     if not test.value:
  467.                         continue
  468.                     
  469.                 
  470.             
  471.             self.visit(test, scope)
  472.             self.visit(body, scope)
  473.         
  474.         if node.else_:
  475.             self.visit(node.else_, scope)
  476.         
  477.  
  478.     
  479.     def visitYield(self, node, scope):
  480.         scope.generator = 1
  481.         self.visit(node.value, scope)
  482.  
  483.  
  484.  
  485. def list_eq(l1, l2):
  486.     return sorted(l1) == sorted(l2)
  487.  
  488.